Products
In-IDE
IDE extension that lets you fix coding issues before they exist!
Discover SonarLint
SaaS
Setup is effortless and analysis is automatic for most languages
Discover SonarCloud
Self-Hosted
Fast, accurate analysis; enterprise scalability
Discover SonarQube

Secrets
ABAP
Ansible
Apex
AzureResourceManager
C
C#
C++
CloudFormation
COBOL
CSS
Dart
Docker
Flex
Go
HTML
Java
JavaScript
JCL
Kotlin
Kubernetes
Objective C
PHP
PL/I
PL/SQL
Python
RPG
Ruby
Scala
Swift
Terraform
Text
TypeScript
T-SQL
VB.NET
VB6
XML

PHP static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your PHP code

Tags

Impact

Clean code attribute

Test class names should end with "Test"
Code Smell
Tests should include assertions
Code Smell
TestCases should contain tests
Code Smell
Variable variables should not be used
Code Smell
Switch cases should end with an unconditional "break" statement
Code Smell
Unnecessary parentheses should not be used for constructs
Code Smell
Constants should not be used as conditions
Code Smell
`str_replace` should be preferred to `preg_replace`
Code Smell
"default" clauses should be first or last
Code Smell
A conditionally executed single line should be denoted by indentation
Code Smell
Conditionals should start on new lines
Code Smell
Cognitive Complexity of functions should not be too high
Code Smell
Functions should not be nested too deeply
Code Smell
References should not be passed to function calls
Code Smell
"switch" statements should have "default" clauses
Code Smell
Control structures should use curly braces
Code Smell
String literals should not be duplicated
Code Smell
Methods should not be empty
Code Smell
Constant names should comply with a naming convention
Code Smell
"goto" statement should not be used
Code Smell
Character classes in regular expressions should not contain only one character
Code Smell
Superfluous curly brace quantifiers should be avoided
Code Smell
Non-capturing groups without quantifier should not be used
Code Smell
WordPress option names should not be misspelled
Code Smell
WordPress options should not be defined at the end of "wp-config.php"
Code Smell
Constants should not be redefined
Code Smell
Regular expressions should not contain empty groups
Code Smell
Regular expressions should not contain multiple spaces
Code Smell
Single-character alternations in regular expressions should be replaced with character classes
Code Smell
Reluctant quantifiers in regular expressions should be followed by an expression that can't match the empty string
Code Smell
Character classes in regular expressions should not contain the same character twice
Code Smell
Regular expressions should not be too complicated
Code Smell
PHPUnit assertTrue/assertFalse should be simplified to the corresponding dedicated assertion
Code Smell
Use of namespaces should be preferred to "include" or "require" functions
Code Smell
Methods should not have identical implementations
Code Smell
Functions should use "return" consistently
Code Smell
Assertion arguments should be passed in the correct order
Code Smell
Ternary operators should not be nested
Code Smell
Reflection should not be used to increase accessibility of classes, methods, or fields
Code Smell
Multiline blocks should be enclosed in curly braces
Code Smell
Parameters should be passed in the correct order
Code Smell
Classes named like "Exception" should extend "Exception" or a subclass
Code Smell
Two branches in a conditional structure should not have exactly the same implementation
Code Smell
Unused assignments should be removed
Code Smell
Method arguments with default values should be last
Code Smell
A reason should be provided when skipping a test
Code Smell
"__construct" functions should not make PHP 4-style calls to parent constructors
Code Smell
Deprecated constructor declarations should not be used
Code Smell
Deprecated predefined variables should not be used
Code Smell
"switch" statements should not have too many "case" clauses
Code Smell
Classes should not have too many methods
Code Smell
Functions should not have too many lines of code
Code Smell
"for" loop stop conditions should be invariant
Code Smell
Sections of code should not be commented out
Code Smell
Unused function parameters should be removed
Code Smell
Unused "private" methods should be removed
Code Smell
Functions should not contain too many return statements
Code Smell
Track uses of "FIXME" tags
Code Smell
Generic exceptions ErrorException, RuntimeException and Exception should not be thrown
Code Smell
Redundant pairs of parentheses should be removed
Code Smell
Inheritance tree of classes should not be too deep
Code Smell
Nested blocks of code should not be left empty
Code Smell
Functions should not have too many parameters
Code Smell
Unused "private" fields should be removed
Code Smell
Mergeable "if" statements should be combined
Code Smell
Regular expression quantifiers and character classes should be used concisely
Code Smell
Character classes should be preferred over reluctant quantifiers in regular expressions
Code Smell
A subclass should not be in the same "catch" clause as a parent class
Code Smell
Jump statements should not be redundant
Code Smell
"catch" clauses should do more than rethrow
Code Smell
"&&" and "||" should be used
Code Smell
Boolean checks should not be inverted
Code Smell
"elseif" keyword should be used in place of "else if" keywords
Code Smell
PHP keywords and constants "true", "false", "null" should be lower case
Code Smell
Closing tag "?>" should be omitted on files containing only PHP
Code Smell
More than one property should not be declared per statement
Code Smell
The "var" keyword should not be used
Code Smell
"<?php" and "<?=" tags should be used
Code Smell
Local variables should not be declared and then immediately returned or thrown
Code Smell
Unused local variables should be removed
Code Smell
"switch" statements should have at least 3 "case" clauses
Code Smell
A "while" loop should be used instead of a "for" loop
Code Smell
Overriding methods should do more than simply call the same method in the super class
Code Smell
Local variable and function parameter names should comply with a naming convention
Code Smell
Field names should comply with a naming convention
Code Smell
"empty()" should be used to test for emptiness
Code Smell
Interface names should comply with a naming convention
Code Smell
Lines should not end with trailing whitespaces
Code Smell
Files should end with a newline
Code Smell
Return of boolean expressions should not be wrapped into an "if-then-else" statement
Code Smell
Boolean literals should not be redundant
Code Smell
Modifiers should be declared in the correct order
Code Smell
Empty statements should be removed
Code Smell
A close curly brace should be located at the beginning of a line
Code Smell
URIs should not be hardcoded
Code Smell
Tabulation characters should not be used
Code Smell
Class names should comply with a naming convention
Code Smell
Function names should comply with a naming convention
Code Smell
Track uses of "TODO" tags
Code Smell
Functions and variables should not be defined outside of classes
Code Smell
Track lack of copyright and license headers
Code Smell
Octal values should not be used
Code Smell
Literal boolean values and nulls should not be used in equality assertions
Code Smell
Parentheses should not be used for calls to "echo"
Code Smell
"global" should not be used
Code Smell
"switch" statements should not be nested
Code Smell
Cyclomatic Complexity of functions should not be too high
Code Smell
Control flow statements "if", "for", "while", "switch" and "try" should not be nested too deeply
Code Smell
Cyclomatic Complexity of classes should not be too high
Code Smell
"if ... else if" constructs should end with "else" clauses
Code Smell
Expressions should not be too complex
Code Smell
Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression
Code Smell
Test methods should be discoverable
Code Smell
Duplicate values should not be passed as arguments
Code Smell
Configuration should not be changed dynamically
Code Smell
Class constructors should not create other objects
Code Smell
PHP parser failure
Code Smell
The names of methods with boolean return values should start with "is" or "has"
Code Smell
"php_sapi_name()" should not be used
Code Smell
Classes should not have too many lines of code
Code Smell
Deprecated features should not be used
Code Smell
Files should not contain inline HTML
Code Smell
Files should contain only one top-level class or interface each
Code Smell
Classes should not have too many fields
Code Smell
Track uses of "NOSONAR" comments
Code Smell
Statements should be on separate lines
Code Smell
Classes should not be coupled to too many other classes
Code Smell
"switch case" clauses should not have too many lines of code
Code Smell
Assignments should not be made from within sub-expressions
Code Smell
Local variables should not have the same name as class fields
Code Smell
Files should not have too many lines of code
Code Smell
Lines should not be too long
Code Smell
Framework-provided functions should be used to test exceptions
Code Smell
Unicode-aware versions of character classes should be preferred
Code Smell
Alias functions should not be used
Code Smell
Perl-style comments should not be used
Code Smell
Superglobals should not be accessed directly
Code Smell
Colors should be defined in upper case
Code Smell
String literals should not be concatenated
Code Smell
"final" should not be used redundantly
Code Smell
Source code should comply with formatting standards
Code Smell
Only LF character (Unix-like) should be used to end lines
Code Smell
File names should comply with a naming convention
Code Smell
Comments should not be located at the end of lines of code
Code Smell
An open curly brace should be located at the beginning of a line
Code Smell
An open curly brace should be located at the end of a line
Code Smell

WordPress options should not be defined at the end of "wp-config.php"

intentionality - logical

maintainability

Code Smell

MajorSonarSource default severity
click to learn more

Why is this an issue?

How can I fix it?

More Info

WordPress makes it possible to define options using define statements inside a configuration file named wp-config.php. However, if the statements are located after the settings are loaded at the end of this file, they are not taken into account by WordPress. This rule raises an issue when a define statement appears after wp-settings.php is loaded.

What is the potential impact?

This issue could entail more serious problems. A configuration that is security related could be ignored and not considered without any warning.

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

© 2008-2024 SonarSource SA. All rights reserved. SONAR, SONARSOURCE, SONARQUBE, and CLEAN AS YOU CODE are trademarks of SonarSource SA.

Sonar helps developers write Clean Code.
Privacy Policy | Cookie Policy

In-IDE

SaaS

Self-Hosted